import java.util.Arrays;

public class Test {
    //   public static void main1(String[] args) {
        //二维数组：特殊的一维数组 二维数组相当于一维数组 只不过数组数组是一维数组
        //基本语法：数据类型[][] 数组名 = new 数据类型[行数][列数]{初始化数据};
        //定义二维数组方法：
//        int[][] array1 = {{1,2,3},{4,5,6}};//直接初始化
//        int[][] array2 = new int[][]{{1,2,3},{4,5,6}};//完整版直接初始化
//        int[][] array3 = new int[2][3];//默认初始化值为0
//
//        //二维数组的打印
//        //遍历打印
//        for(int i = 0;i < array1.length;i++) {//直接求二维数组长度为行数
//            for(int j = 0;j < array1[i].length;j++) {//求i 为列数
//                System.out.print(array1[i][j] + " ");
//            }
//            System.out.println();
//        }
//        //for each打印
//        for (int[] tmpArray:array1 ) {
//            for (int x:tmpArray ) {
//                System.out.print(x + " ");
//            }
//            System.out.println();
//        }
//        //方法打印 Arrays.deepToString
//        System.out.print(Arrays.deepToString(array1));

        //不规则数组:列的个数不一定要与每行个数相同
//        int[][] array = {{1,2,3,4,5},{2,2,3,4}};//初始化设定不规则数组
//
//        int[][] array1 = new int[2][];//可以省略列 不能省略行
//        array1[0] = new int[]{1,2,3,4};//new行数组值
//        array1[1] = new int[]{2,3,4};
//    }

    //面向对象 OOP
    //写几个类
    //语法 class ClassName(大驼峰) {
    // field;//字段/属性/成员变量
    //mothod;//行为/成员方法
    // }
    //1.一般一个文件当中只定义一个类
    //2. main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)
    //3. public修饰的类必须要和文件名相同
    //4. 不要轻易去修改public修饰的类的名称，如果要修改，通过开发工具修改(给同学演示)。
    public static void main(String[] args) {

        //实例化：类产生对象
        //三个问题
        //交换值
    }
}

//定义洗衣机类
//class WashMachine {
//    //成员变量/属性/字段 ：创建在类内 方法外
//    public String brand; // 品牌
//    public String type; // 型号
//    public double weight; // 重量
//    public double length; // 长
//    public double width; // 宽
//    public double height; // 高
//    public String color; // 颜色
//
//    //成员方法/行为：
//    public void washClothes() {
//
//    }
//
//}
//定义狗类
//class Dog {
//    //成员变量/属性/字段
//    public String name;
//    public int age;
//    public String color;
//
//    //成员方法/行为
//    public void barks() {
//        System.out.println(name + ":汪汪汪~~");
//    }
//
//    public void wag() {
//        System.out.println(name + ":摇尾巴");
//    }
//
//    public static void main(String[] args) {
        //类的实例化
       // new 关键字用于创建一个对象的实例.
        //使用 . 来访问对象中的属性和方法.
        //同一个类可以创建对个实例.
//        Dog dog1 = new Dog();
//        dog1.name = "大黄";
//        System.out.println("姓名：" + dog1.name);
//        dog1.age = 1;
//        System.out.println(dog1.age + "岁");
//        dog1.color = "黄色";
//        System.out.println(dog1.color + "毛发");
//        dog1.barks();
//
//        Dog dog2 = new Dog();
//        dog2.name = "旺财";
//        System.out.println("姓名：" + dog2.name);
//        dog2.age = 2;
//        System.out.println(dog2.age + "岁");
//        dog2.color = "灰色";
//        System.out.println(dog2.color + "毛发");
//        dog2.wag();
//    }
//}
//
////定义student类
//class student {
//    //属性/成员变量/字段
//    public String name;
//    public int age;
//    public double score;
//    //方法/行为
//    public void Exam() {
//        System.out.println(name + "考试");
//    }
//}
//this引用指向当前对象(成员方法运行时调用该成员方法的对象)，
//在成员方法中所有成员变量的操作，都是通过该引用去访问
// this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
//2. this只能在"成员方法"中使用
//3. 在"成员方法"中，this只能引用当前对象，不能再引用其他对象
//4. this是“成员方法”第一个隐藏的参数，编译器会自动传递，
// 在成员方法执行时，编译器会负责将调用成员方法
//对象的引用传递给该成员方法，this负责来接收
class Data {
    //属性/字段/变量
    public int year;
    public int month;
    public int day;
    //方法/行为
    public void setDay(int year,int month,int day) {//创建day
    this.year = year;//this引用表示指向该year 防止因为同名问题导致局部变量优先使用导致为0
    this.month = month;
    this.day = day;
    }
    public void printData() {//打印
        System.out.println(this.year + "/" + this.month + "/" + this.day);
        //建议加上 即使不加无影响
    }

//    public Data(int year) {//1. 名字必须与类名相同
//        //2. 没有返回值类型，设置为void也不行
//        //3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)
//        this.year = 2000;
//        System.out.println("执行了该构造方法....");
//    }

    //4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)
    //5. 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的
    public Data() {//6. 构造方法中，可以通过this调用其他构造方法来简化代码
        this(2005,5,1);//在空创造方法中调用其他创造方法
        // 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
        // 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
        // 但是this(1900,1,1);必须是构造方法中第一条语句
        //不能形成环
        System.out.println("执行了该语句...");
        //this.month = month;
    }
    public Data(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public static void main(String[] args) {
//        Data day1 = new Data();
//        day1.setDay(1999,10,1);
//        day1.printData();
//        Data day2 = new Data();
//        day2.setDay(2000,10,1);
//        day2.printData();
//        //对象构造初始化
//        //默认初始化
//        Data day3 = new Data();//不进行赋值时 会有一个idea规定的初始值 int 为 0 boolean false 引用类型 null
//        System.out.println(day3.year);
//        System.out.println(day3.month);
//        System.out.println(day3.day);
//        //就地初始化 : 在创建属性/变量/字段时 赋予初始值 如果为定义就打印赋予的初始值
//        Data day4 = new Data();
//        System.out.println(day4.year);
//        System.out.println(day4.month);
//        System.out.println(day4.day);
        //构造初始化构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，
        // 在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。
        //无参构造器调用三个参数的构造器，而三个参数构造器有调用无参的构造器，形成构造器的递归调用
        //编译报错：Error:(19, 12) java: 递归构造器调用
        //解析上面错误 如果在空创造方法中使用this
        // 而this调用的创造方法中又存在this调用时，会报上述错误
        Data day = new Data();
        day.printData();
    }
}

